home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 351-375 / disk_365 / view80 / src / filefinder.c < prev    next >
C/C++ Source or Header  |  1992-05-06  |  29KB  |  1,519 lines
  1. /***************************************************************************
  2.  
  3.                         F I L E - F I N D E R
  4.                        ^^^^^^^^^^^^^^^^^^^^^^^
  5.  
  6.                         by  Federico Giannici
  7.  
  8.  
  9.  
  10. Inizio  27/10/88           Attuale 01/12/89                 V 1.5
  11.  
  12.  
  13. Routine generalizzata di richiesta del nome di un file.
  14.  
  15.  
  16. filefinder( data )
  17.     struct  ffdata *data;          Struttura dati da usare (vedi definizione)
  18.  
  19.  
  20. Necessita apertura librerie:
  21.     Intuition.library   (da 1.2 in poi)
  22.     Graphics.library
  23.  
  24.  
  25. ***************************************************************************/
  26.  
  27.  
  28. #include    "general.h"
  29. #include    "MyRoutines/FileFinder.h"
  30.  
  31.  
  32. #define FFMAXLEN    FFPATHLEN
  33.  
  34. #define FFLINELEN   33
  35. #define FFLINENUM   8
  36.  
  37. #define FFCOLORA    2
  38. #define FFCOLORA2   0
  39. #define FFCOLORB    1
  40. #define FFCOLORO    3
  41. #define FFCOLORS    0
  42. #define FFCOLORDF0  1
  43. #define FFCOLORDF1  2
  44. #define FFCOLORDF2  3
  45.  
  46. #define FFWTOP      9
  47. #define FFWWIDTH    312
  48. #define FFWHEIGHT   (180+FFWTOP)
  49.  
  50. #define FFDFNOVALID (-1)
  51.  
  52. #define FFMIN(a,b)  ((a)<(b)?(a):(b))
  53. #define FFTOUP(c)   ( c>='a' && c<='z' ? c-('a'-'A') : c )
  54.  
  55.  
  56. /*****   Le mie proto   *****/
  57. void    ffshowall( void );
  58. void    ffsetprop( void );
  59. void    ffchangepath( void );
  60. void    ffunlock( void );
  61. void    ffoutdiskfree( ULONG );
  62. void    fffinddevices( void );
  63. LONG    ffopenwindow( void );
  64. LONG    ffaddline( void );
  65. LONG    ffaddshow( LONG );
  66. LONG    ffstrcmpu( UBYTE *, UBYTE * );
  67.  
  68.  
  69.  
  70. UBYTE    novalidpath[]="Not A Valid Path!";
  71. #define    NOVALIDPATHLEN    17
  72.  
  73. UBYTE   ffundobuff[ FFMAXLEN+1 ];
  74.  
  75. struct  TextAttr    fffont=
  76.     {
  77.     "topaz.font",
  78.     8,
  79.     0, 0
  80.     };
  81.  
  82.  
  83. struct  Image   ffig24;
  84. struct  PropInfo    ffpg24=
  85.     {
  86.     FREEVERT | PROPBORDERLESS | AUTOKNOB,
  87.     0,
  88.     0,
  89.     0,
  90.     0xFFFF,
  91.     NULL,
  92.     NULL,
  93.     NULL, NULL,
  94.     NULL,
  95.     NULL
  96.     };
  97. struct  Gadget  ffg24=
  98.     {
  99.     NULL,
  100.     282, 80+FFWTOP,
  101.     18, 52,
  102.     GADGHCOMP | GADGIMAGE,
  103.     GADGIMMEDIATE,
  104.     PROPGADGET,
  105.     ( APTR )&ffig24,
  106.     NULL,
  107.     NULL,
  108.     NULL,
  109.     ( APTR )&ffpg24,
  110.     24,
  111.     NULL
  112.     };
  113.  
  114. SHORT   ffdbg23c[ 4*2 ]=
  115.     {
  116.     10, 9,
  117.     17, 2,
  118.     3, 2,
  119.     10, 9
  120.     };
  121. SHORT   ffdbg22c[ 4*2 ]=
  122.     {
  123.     10, 2,
  124.     17, 9,
  125.     3, 9,
  126.     10, 2
  127.     };
  128. SHORT   ffdbg22[ 5*2 ]=
  129.     {
  130.     -1, 0,
  131.     21, 0,
  132.     21, 11,
  133.     -1, 11,
  134.     -1, 0
  135.     };
  136. struct  Border  ffbg23d=
  137.     {
  138.     1, 0,
  139.     FFCOLORA, FFCOLORB,
  140.     JAM1,
  141.     4,
  142.     (SHORT *)&ffdbg23c,
  143.     NULL
  144.     };
  145. struct  Border  ffbg23c=
  146.     {
  147.     0, 0,
  148.     FFCOLORA, FFCOLORB,
  149.     JAM1,
  150.     4,
  151.     (SHORT *)&ffdbg23c,
  152.     &ffbg23d
  153.     };
  154. struct  Border  ffbg23b=
  155.     {
  156.     1, 0,
  157.     FFCOLORA, FFCOLORB,
  158.     JAM1,
  159.     5,
  160.     (SHORT *)&ffdbg22,
  161.     &ffbg23c
  162.     };
  163. struct  Border  ffbg23=
  164.     {
  165.     0, 0,
  166.     FFCOLORA, FFCOLORB,
  167.     JAM1,
  168.     5,
  169.     (SHORT *)&ffdbg22,
  170.     &ffbg23b
  171.     };
  172. struct  Gadget  ffg23=
  173.     {
  174.     &ffg24,
  175.     280, 132+FFWTOP,
  176.     22, 12,
  177.     GADGHCOMP,
  178.     RELVERIFY | GADGIMMEDIATE,
  179.     BOOLGADGET,
  180.     ( APTR )&ffbg23,
  181.     NULL,
  182.     NULL,
  183.     NULL,
  184.     NULL,
  185.     23,
  186.     NULL
  187.     };
  188.  
  189. struct  Border  ffbg22d=
  190.     {
  191.     1, 0,
  192.     FFCOLORA, FFCOLORB,
  193.     JAM1,
  194.     4,
  195.     (SHORT *)&ffdbg22c,
  196.     NULL
  197.     };
  198. struct  Border  ffbg22c=
  199.     {
  200.     0, 0,
  201.     FFCOLORA, FFCOLORB,
  202.     JAM1,
  203.     4,
  204.     (SHORT *)&ffdbg22c,
  205.     &ffbg22d
  206.     };
  207. struct  Border  ffbg22b=
  208.     {
  209.     1, 0,
  210.     FFCOLORA, FFCOLORB,
  211.     JAM1,
  212.     5,
  213.     (SHORT *)&ffdbg22,
  214.     &ffbg22c
  215.     };
  216. struct  Border  ffbg22=
  217.     {
  218.     0, 0,
  219.     FFCOLORA, FFCOLORB,
  220.     JAM1,
  221.     5,
  222.     (SHORT *)&ffdbg22,
  223.     &ffbg22b
  224.     };
  225. struct  Gadget  ffg22=
  226.     {
  227.     &ffg23,
  228.     280, 68+FFWTOP,
  229.     22, 12,
  230.     GADGHCOMP,
  231.     RELVERIFY | GADGIMMEDIATE,
  232.     BOOLGADGET,
  233.     ( APTR )&ffbg22,
  234.     NULL,
  235.     NULL,
  236.     NULL,
  237.     NULL,
  238.     22,
  239.     NULL
  240.     };
  241.  
  242. struct  StringInfo  ffsg21=
  243.     {
  244.     NULL,
  245.     ffundobuff,
  246.     0,
  247.     FFFILELEN+1,
  248.     0,
  249.     NULL,
  250.     NULL,
  251.     NULL,
  252.     NULL, NULL,
  253.     NULL,
  254.     NULL,
  255.     NULL,
  256.     };
  257. struct  IntuiText   fftg21=
  258.     {
  259.     FFCOLORA, FFCOLORB,
  260.     JAM1,
  261.     -40-2, 0,
  262.     &fffont,
  263.     "File:",
  264.     NULL
  265.     };
  266. struct  Gadget  ffg21=
  267.     {
  268.     &ffg22,
  269.     51+2, 146+1+FFWTOP,
  270.     248, 10,
  271.     GADGHCOMP,
  272.     RELVERIFY,
  273.     STRGADGET,
  274.     NULL,
  275.     NULL,
  276.     &fftg21,
  277.     NULL,
  278.     ( APTR )&ffsg21,
  279.     21,
  280.     NULL
  281.     };
  282.  
  283. struct  StringInfo  ffsg20=
  284.     {
  285.     NULL,
  286.     ffundobuff,
  287.     0,
  288.     FFPATHLEN+1,
  289.     0,
  290.     NULL,
  291.     NULL,
  292.     NULL,
  293.     NULL, NULL,
  294.     NULL,
  295.     NULL,
  296.     NULL,
  297.     };
  298. struct  IntuiText   fftg20=
  299.     {
  300.     FFCOLORA, FFCOLORB,
  301.     JAM1,
  302.     -40-2, 0,
  303.     &fffont,
  304.     "Path:",
  305.     NULL
  306.     };
  307. struct  Gadget  ffg20=
  308.     {
  309.     &ffg21,
  310.     51+2, 56+1+FFWTOP,
  311.     248, 10,
  312.     GADGHCOMP,
  313.     RELVERIFY,
  314.     STRGADGET,
  315.     NULL,
  316.     NULL,
  317.     &fftg20,
  318.     NULL,
  319.     ( APTR )&ffsg20,
  320.     20,
  321.     NULL
  322.     };
  323.  
  324. struct  StringInfo  ffsg19=
  325.     {
  326.     NULL,
  327.     ffundobuff,
  328.     0,
  329.     FFSUFFIXLEN+1,
  330.     0,
  331.     NULL,
  332.     NULL,
  333.     NULL,
  334.     NULL, NULL,
  335.     NULL,
  336.     NULL,
  337.     NULL,
  338.     };
  339. struct  IntuiText   fftg19=
  340.     {
  341.     FFCOLORA, FFCOLORB,
  342.     JAM1,
  343.     -56-2, 0,
  344.     &fffont,
  345.     "Suffix:",
  346.     NULL
  347.     };
  348. struct  Gadget  ffg19=
  349.     {
  350.     &ffg20,
  351.     235+2, 44+1+FFWTOP,
  352.     64, 10,
  353.     GADGHCOMP,
  354.     RELVERIFY,
  355.     STRGADGET,
  356.     NULL,
  357.     NULL,
  358.     &fftg19,
  359.     NULL,
  360.     ( APTR )&ffsg19,
  361.     19,
  362.     NULL
  363.     };
  364.  
  365. SHORT   ffdbg11[ 5*2 ]=
  366.     {
  367.     -4, -2,
  368.     264+2, -2,
  369.     264+2, 73,
  370.     -4, 73,
  371.     -4, -2
  372.     };
  373. struct  Border  ffbg11b=
  374.     {
  375.     1, 0,
  376.     FFCOLORA, FFCOLORB,
  377.     JAM1,
  378.     5,
  379.     (SHORT *)&ffdbg11,
  380.     NULL
  381.     };
  382. struct  Border  ffbg11=
  383.     {
  384.     0, 0,
  385.     FFCOLORA, FFCOLORB,
  386.     JAM1,
  387.     5,
  388.     (SHORT *)&ffdbg11,
  389.     &ffbg11b
  390.     };
  391.  
  392. struct  Gadget  ffg18=
  393.     {
  394.     &ffg19,
  395.     13, 70+7*9+FFWTOP,
  396.     264, 9,
  397.     GADGHCOMP,
  398.     GADGIMMEDIATE | RELVERIFY,
  399.     BOOLGADGET,
  400.     NULL,
  401.     NULL,
  402.     NULL,
  403.     NULL,
  404.     NULL,
  405.     18,
  406.     NULL
  407.     };
  408.  
  409. struct  Gadget  ffg17=
  410.     {
  411.     &ffg18,
  412.     13, 70+6*9+FFWTOP,
  413.     264, 9,
  414.     GADGHCOMP,
  415.     GADGIMMEDIATE | RELVERIFY,
  416.     BOOLGADGET,
  417.     NULL,
  418.     NULL,
  419.     NULL,
  420.     NULL,
  421.     NULL,
  422.     17,
  423.     NULL
  424.     };
  425.  
  426. struct  Gadget  ffg16=
  427.     {
  428.     &ffg17,
  429.     13, 70+5*9+FFWTOP,
  430.     264, 9,
  431.     GADGHCOMP,
  432.     GADGIMMEDIATE | RELVERIFY,
  433.     BOOLGADGET,
  434.     NULL,
  435.     NULL,
  436.     NULL,
  437.     NULL,
  438.     NULL,
  439.     16,
  440.     NULL
  441.     };
  442.  
  443. struct  Gadget  ffg15=
  444.     {
  445.     &ffg16,
  446.     13, 70+4*9+FFWTOP,
  447.     264, 9,
  448.     GADGHCOMP,
  449.     GADGIMMEDIATE | RELVERIFY,
  450.     BOOLGADGET,
  451.     NULL,
  452.     NULL,
  453.     NULL,
  454.     NULL,
  455.     NULL,
  456.     15,
  457.     NULL
  458.     };
  459.  
  460. struct  Gadget  ffg14=
  461.     {
  462.     &ffg15,
  463.     13, 70+3*9+FFWTOP,
  464.     264, 9,
  465.     GADGHCOMP,
  466.     GADGIMMEDIATE | RELVERIFY,
  467.     BOOLGADGET,
  468.     NULL,
  469.     NULL,
  470.     NULL,
  471.     NULL,
  472.     NULL,
  473.     14,
  474.     NULL
  475.     };
  476.  
  477. struct  Gadget  ffg13=
  478.     {
  479.     &ffg14,
  480.     13, 70+2*9+FFWTOP,
  481.     264, 9,
  482.     GADGHCOMP,
  483.     GADGIMMEDIATE | RELVERIFY,
  484.     BOOLGADGET,
  485.     NULL,
  486.     NULL,
  487.     NULL,
  488.     NULL,
  489.     NULL,
  490.     13,
  491.     NULL
  492.     };
  493.  
  494. struct  Gadget  ffg12=
  495.     {
  496.     &ffg13,
  497.     13, 70+1*9+FFWTOP,
  498.     264, 9,
  499.     GADGHCOMP,
  500.     GADGIMMEDIATE | RELVERIFY,
  501.     BOOLGADGET,
  502.     NULL,
  503.     NULL,
  504.     NULL,
  505.     NULL,
  506.     NULL,
  507.     12,
  508.     NULL
  509.     };
  510.  
  511. struct  Gadget  ffg11=
  512.     {
  513.     &ffg12,
  514.     13, 70+FFWTOP,
  515.     264, 9,
  516.     GADGHCOMP,
  517.     GADGIMMEDIATE | RELVERIFY,
  518.     BOOLGADGET,
  519.     ( APTR )&ffbg11,
  520.     NULL,
  521.     NULL,
  522.     NULL,
  523.     NULL,
  524.     11,
  525.     NULL
  526.     };
  527.  
  528. SHORT   ffdbg7[ 9*2 ]=
  529.     {
  530.     9, 12,
  531.     69, 12,
  532.     78, 8,
  533.     78, 4,
  534.     69, 0,
  535.     9, 0,
  536.     0, 4,
  537.     0, 8,
  538.     9, 12
  539.     };
  540.  
  541. SHORT   ffdbg9[ 9*2 ]=
  542.     {
  543.     11, 0,
  544.     75, 0,
  545.     86, 5,
  546.     86, 11,
  547.     75, 16,
  548.     11, 16,
  549.     0, 11,
  550.     0, 5,
  551.     11, 0
  552.     };
  553.  
  554. struct  Border  ffbg9d=
  555.     {
  556.     5, 2,
  557.     FFCOLORA, FFCOLORB,
  558.     JAM1,
  559.     9,
  560.     (SHORT *)&ffdbg7,
  561.     NULL
  562.     };
  563. struct  Border  ffbg9c=
  564.     {
  565.     4, 2,
  566.     FFCOLORA, FFCOLORB,
  567.     JAM1,
  568.     9,
  569.     (SHORT *)&ffdbg7,
  570.     &ffbg9d
  571.     };
  572. struct  Border  ffbg9b=
  573.     {
  574.     1, 0,
  575.     FFCOLORO, FFCOLORB,
  576.     JAM1,
  577.     9,
  578.     (SHORT *)&ffdbg9,
  579.     &ffbg9c
  580.     };
  581. struct  Border  ffbg9=
  582.     {
  583.     0, 0,
  584.     FFCOLORO, FFCOLORB,
  585.     JAM1,
  586.     9,
  587.     (SHORT *)&ffdbg9,
  588.     &ffbg9b
  589.     };
  590.  
  591. struct  IntuiText   fftg10=
  592.     {
  593.     FFCOLORA, FFCOLORB,
  594.     JAM1,
  595.     20, 5,
  596.     &fffont,
  597.     "CANCEL",
  598.     NULL
  599.     };
  600. struct  Gadget  ffg10=
  601.     {
  602.     &ffg11,
  603.     204-4, 159+FFWTOP,
  604.     88, 17,
  605.     GADGHCOMP,
  606.     RELVERIFY,
  607.     BOOLGADGET,
  608.     ( APTR )&ffbg9,
  609.     NULL,
  610.     &fftg10,
  611.     NULL,
  612.     NULL,
  613.     10,
  614.     NULL
  615.     };
  616.  
  617. struct  IntuiText   fftg9b=
  618.     {
  619.     FFCOLORA, FFCOLORB,
  620.     JAM1,
  621.     36, 5,
  622.     &fffont,
  623.     "OK",
  624.     NULL
  625.     };
  626. struct  IntuiText   fftg9=
  627.     {
  628.     FFCOLORA, FFCOLORB,
  629.     JAM1,
  630.     35, 5,
  631.     &fffont,
  632.     "OK",
  633.     &fftg9b
  634.     };
  635. struct  Gadget  ffg9=
  636.     {
  637.     &ffg10,
  638.     26-4, 159+FFWTOP,
  639.     88, 17,
  640.     GADGHCOMP,
  641.     RELVERIFY,
  642.     BOOLGADGET,
  643.     ( APTR )&ffbg9,
  644.     NULL,
  645.     &fftg9,
  646.     NULL,
  647.     NULL,
  648.     9,
  649.     NULL
  650.     };
  651.  
  652. struct  Border  ffbg7e=
  653.     {
  654.     3, 1,
  655.     FFCOLORA, FFCOLORB,
  656.     JAM1,
  657.     4,
  658.     (SHORT *)&ffdbg7,
  659.     NULL
  660.     };
  661. struct  Border  ffbg7d=
  662.     {
  663.     2, 1,
  664.     FFCOLORA, FFCOLORB,
  665.     JAM1,
  666.     4,
  667.     (SHORT *)&ffdbg7,
  668.     &ffbg7e
  669.     };    
  670. struct  Border  ffbg7c=
  671.     {
  672.     1, 1,
  673.     FFCOLORA, FFCOLORB,
  674.     JAM1,
  675.     4,
  676.     (SHORT *)&ffdbg7,
  677.     &ffbg7d
  678.     };
  679. struct  Border  ffbg7b=
  680.     {
  681.     1, 0,
  682.     FFCOLORA, FFCOLORB,
  683.     JAM1,
  684.     9,
  685.     (SHORT *)&ffdbg7,
  686.     &ffbg7c
  687.     };    
  688. struct  Border  ffbg7=
  689.     {
  690.     0, 0,
  691.     FFCOLORA, FFCOLORB,
  692.     JAM1,
  693.     9,
  694.     (SHORT *)&ffdbg7,
  695.     &ffbg7b
  696.     };
  697.  
  698. struct  IntuiText   fftg8=
  699.     {
  700.     FFCOLORA, FFCOLORB,
  701.     JAM1,
  702.     18, 3,
  703.     &fffont,
  704.     "Parent",
  705.     NULL
  706.     };
  707. struct  Gadget  ffg8=
  708.     {
  709.     &ffg9,
  710.     204, 24+FFWTOP,
  711.     82, 14,
  712.     GADGHCOMP,
  713.     RELVERIFY,
  714.     BOOLGADGET,
  715.     ( APTR )&ffbg7,
  716.     NULL,
  717.     &fftg8,
  718.     NULL,
  719.     NULL,
  720.     8,
  721.     NULL
  722.     };
  723.  
  724. struct  IntuiText   fftg7=
  725.     {
  726.     FFCOLORA, FFCOLORB,
  727.     JAM1,
  728.     26, 3,
  729.     &fffont,
  730.     "Read",
  731.     NULL
  732.     };
  733. struct  Gadget  ffg7=
  734.     {
  735.     &ffg8,
  736.     26, 24+FFWTOP,
  737.     82, 14,
  738.     GADGHCOMP,
  739.     RELVERIFY,
  740.     BOOLGADGET,
  741.     ( APTR )&ffbg7,
  742.     NULL,
  743.     &fftg7,
  744.     NULL,
  745.     NULL,
  746.     7,
  747.     NULL
  748.     };
  749.  
  750. SHORT   ffdbg1[ 5*2 ]=
  751.     {
  752.     0, 0,
  753.     47, 0,
  754.     47, 15,
  755.     0, 15,
  756.     0, 0
  757.     };
  758. struct  Border  ffbg1=
  759.     {
  760.     0, 0,
  761.     FFCOLORA, FFCOLORB,
  762.     JAM1,
  763.     5,
  764.     (SHORT *)&ffdbg1,
  765.     NULL
  766.     };
  767.  
  768. struct  IntuiText   fftg6=
  769.     {
  770.     FFCOLORA, FFCOLORB,
  771.     JAM1,
  772.     8, 4,
  773.     &fffont,
  774.     "RAD:",
  775.     NULL
  776.     };
  777. struct  Gadget  ffg6=
  778.     {
  779.     &ffg7,
  780.     12+5*48, 5+FFWTOP,
  781.     48, 16,
  782.     GADGHCOMP | GADGDISABLED,
  783.     RELVERIFY,
  784.     BOOLGADGET,
  785.     ( APTR )&ffbg1,
  786.     NULL,
  787.     &fftg6,
  788.     NULL,
  789.     NULL,
  790.     6,
  791.     NULL
  792.     };
  793.  
  794. struct  IntuiText   fftg5=
  795.     {
  796.     FFCOLORA, FFCOLORB,
  797.     JAM1,
  798.     8, 4,
  799.     &fffont,
  800.     "RAM:",
  801.     NULL
  802.     };
  803. struct  Gadget  ffg5=
  804.     {
  805.     &ffg6,
  806.     12+4*48, 5+FFWTOP,
  807.     48, 16,
  808.     GADGHCOMP | GADGDISABLED,
  809.     RELVERIFY,
  810.     BOOLGADGET,
  811.     ( APTR )&ffbg1,
  812.     NULL,
  813.     &fftg5,
  814.     NULL,
  815.     NULL,
  816.     5,
  817.     NULL
  818.     };
  819.  
  820. struct  IntuiText   fftg4=
  821.     {
  822.     FFCOLORA, FFCOLORB,
  823.     JAM1,
  824.     8, 4,
  825.     &fffont,
  826.     "DH0:",
  827.     NULL
  828.     };
  829. struct  Gadget  ffg4=
  830.     {
  831.     &ffg5,
  832.     12+3*48, 5+FFWTOP,
  833.     48, 16,
  834.     GADGHCOMP | GADGDISABLED,
  835.     RELVERIFY,
  836.     BOOLGADGET,
  837.     ( APTR )&ffbg1,
  838.     NULL,
  839.     &fftg4,
  840.     NULL,
  841.     NULL,
  842.     4,
  843.     NULL
  844.     };
  845.  
  846. struct  IntuiText   fftg3=
  847.     {
  848.     FFCOLORA, FFCOLORB,
  849.     JAM1,
  850.     8, 4,
  851.     &fffont,
  852.     "DF2:",
  853.     NULL
  854.     };
  855. struct  Gadget  ffg3=
  856.     {
  857.     &ffg4,
  858.     12+2*48, 5+FFWTOP,
  859.     48, 16,
  860.     GADGHCOMP | GADGDISABLED,
  861.     RELVERIFY,
  862.     BOOLGADGET,
  863.     ( APTR )&ffbg1,
  864.     NULL,
  865.     &fftg3,
  866.     NULL,
  867.     NULL,
  868.     3,
  869.     NULL
  870.     };
  871.  
  872. struct  IntuiText   fftg2=
  873.     {
  874.     FFCOLORA, FFCOLORB,
  875.     JAM1,
  876.     8, 4,
  877.     &fffont,
  878.     "DF1:",
  879.     NULL
  880.     };
  881. struct  Gadget  ffg2=
  882.     {
  883.     &ffg3,
  884.     12+1*48, 5+FFWTOP,
  885.     48, 16,
  886.     GADGHCOMP | GADGDISABLED,
  887.     RELVERIFY,
  888.     BOOLGADGET,
  889.     ( APTR )&ffbg1,
  890.     NULL,
  891.     &fftg2,
  892.     NULL,
  893.     NULL,
  894.     2,
  895.     NULL
  896.     };
  897.  
  898. struct  IntuiText   fftg1=
  899.     {
  900.     FFCOLORA, FFCOLORB,
  901.     JAM1,
  902.     8, 4,
  903.     &fffont,
  904.     "DF0:",
  905.     NULL
  906.     };
  907. struct  Gadget  ffg1=
  908.     {
  909.     &ffg2,
  910.     12, 5+FFWTOP,
  911.     48, 16,
  912.     GADGHCOMP | GADGDISABLED,
  913.     RELVERIFY,
  914.     BOOLGADGET,
  915.     ( APTR )&ffbg1,
  916.     NULL,
  917.     &fftg1,
  918.     NULL,
  919.     NULL,
  920.     1,
  921.     NULL
  922.     };
  923.  
  924.  
  925. SHORT   ffdb0[ 5*2 ]=
  926.     {
  927.     0, 0,
  928.     17*8+3+3, 0,
  929.     17*8+3+3, 12,
  930.     0, 12,
  931.     0, 0
  932.     };
  933. struct  Border  ffb0b=
  934.     {
  935.     1, 0,
  936.     FFCOLORA, FFCOLORB,
  937.     JAM1,
  938.     5,
  939.     (SHORT *)&ffdb0,
  940.     NULL
  941.     };
  942. struct  Border  ffb0=
  943.     {
  944.     0, 0,
  945.     FFCOLORA, FFCOLORB,
  946.     JAM1,
  947.     5,
  948.     (SHORT *)&ffdb0,
  949.     &ffb0b
  950.     };
  951.  
  952.  
  953.  
  954. struct  NewWindow   ffnewwindow=
  955.     {
  956.     NULL, NULL,
  957.     FFWWIDTH, FFWHEIGHT,
  958.     FFCOLORA, FFCOLORB,
  959.     GADGETUP | GADGETDOWN,
  960.     WINDOWDRAG | SMART_REFRESH |  ACTIVATE | RMBTRAP ,
  961.     NULL,
  962.     NULL,
  963.     NULL,
  964.     NULL,
  965.     NULL,
  966.     0, 0,
  967.     0, 0,
  968.     CUSTOMSCREEN
  969.     };
  970.  
  971. BYTE    ffshow[ FFMAXLINE ][ FFLINELEN+1 ];
  972.  
  973. LONG    ffshown, ffshowtop, fflasttop;
  974. LONG    ffdiskfree;
  975. LONG    fflock;
  976. SHORT   ffreadstatus;
  977.  
  978. extern struct DosLibrary *DOSBase;
  979.  
  980. struct  Window      *ffwindow;
  981. struct  RastPort    *ffrp;
  982. struct  FileInfoBlock   *fffib;
  983. struct  InfoData    *ffid;
  984. struct  ffdata      *ffdatag;
  985.  
  986. SHORT   lastpos=-1;     /*   non sarebbe necessario   */
  987.  
  988.  
  989. /****************   MAIN ENTRY POINT   *****************/
  990. LONG filefinder( data )
  991.     struct  ffdata  *data;
  992. {
  993.     LONG    errore;
  994.     struct  IntuiMessage    *message;
  995.     ULONG   class;
  996.     ULONG   secs, millisecs;
  997.     ULONG   lsecs, lmillisecs;
  998.     BOOL    doubleclick;
  999.     struct  Gadget  *gadget, *hitg;
  1000.     USHORT  gid;
  1001.     SHORT   pos;
  1002.     LONG    ret;
  1003.     LONG    i23;
  1004.     LONG    readret;
  1005.     LONG    i;
  1006.     SHORT   dlen;
  1007.     
  1008.  
  1009.     ffdatag=data;
  1010.     ffwindow=NULL;
  1011.     fflock=NULL;
  1012.     lsecs=lmillisecs=0;
  1013.     hitg=NULL;
  1014.     
  1015.     fffib=(struct  FileInfoBlock *)AllocMem( sizeof( struct FileInfoBlock ), MEMF_PUBLIC );
  1016.     ffid=(struct InfoData *)AllocMem( sizeof( struct InfoData ), MEMF_PUBLIC );
  1017.     if( !fffib || !ffid )
  1018.         {
  1019.         ret=FFERROR;
  1020.         goto fine;
  1021.         }
  1022.  
  1023.     ffsg19.Buffer=data->suffix;
  1024.     ffsg20.Buffer=data->path;
  1025.     ffsg21.Buffer=data->file;
  1026.  
  1027.     errore=ffopenwindow();
  1028.     if( errore )
  1029.         {
  1030.         ret=FFERROR;
  1031.         goto fine;
  1032.         }
  1033.  
  1034.     ffdiskfree=ffshowtop=ffshown=0;
  1035.     if( data->valid )
  1036.         {
  1037.         for( i=0; i<data->shown; ++i )
  1038.             ffaddshow( i );
  1039.         ffshowtop=data->showtop;
  1040.         ffdiskfree=data->diskfree;
  1041.         ffreadstatus=0;
  1042.         }
  1043.     else
  1044.         ffreadstatus=1;
  1045.     ffsetprop();
  1046.     ffoutdiskfree( ffdiskfree );
  1047.  
  1048.     FOREVER     /* Main Loop */
  1049.         {
  1050.         if( !ffreadstatus && !hitg )
  1051.             WaitPort( ffwindow->UserPort );
  1052.         while( message=(struct IntuiMessage *)GetMsg( ffwindow->UserPort ) )
  1053.             {
  1054.             class=message->Class;
  1055.             secs=message->Seconds;
  1056.             millisecs=message->Micros;
  1057.             gadget=(struct Gadget *)message->IAddress;
  1058.             gid=gadget->GadgetID;
  1059.             ReplyMsg( (struct Message *)message );
  1060.  
  1061.             switch( gid )
  1062.                 {
  1063.                 case 1:
  1064.                 case 2:
  1065.                 case 3:
  1066.                 case 4:
  1067.                 case 5:
  1068.                 case 6:
  1069.                     strcpy( data->path, gadget->GadgetText->IText );
  1070.                     ffchangepath();
  1071.                     break;
  1072.                 case 7:
  1073.                 case 19:
  1074.                 case 20:
  1075.                     ffreadstatus=1;
  1076.                     ActivateGadget( &ffg21, ffwindow, NULL);
  1077.                     break;
  1078.                 case 8:
  1079.                     dlen=strlen( data->path );
  1080.                     for( ; dlen>0; --dlen )
  1081.                         if( data->path[ dlen-1 ]==':' ||
  1082.                                     data->path[ dlen ]=='/' )
  1083.                             break;
  1084.                     data->path[ dlen ]='\0';
  1085.                     ffchangepath();
  1086.                     break;
  1087.                 case 9:
  1088.                 case 21:
  1089.                     ret=FFOK;
  1090.                     goto fine;
  1091.                 case 10:
  1092.                     ret=FFCANCEL;
  1093.                     goto fine;
  1094.                 case 11:
  1095.                 case 12:
  1096.                 case 13:
  1097.                 case 14:
  1098.                 case 15:
  1099.                 case 16:
  1100.                 case 17:
  1101.                 case 18:
  1102.                     if( class==GADGETDOWN )
  1103.                         {
  1104.                         hitg=gadget;
  1105.                         break;
  1106.                         }
  1107.                     if( ffreadstatus==1 )
  1108.                         {
  1109.                         DisplayBeep( data->screen );
  1110.                         break;
  1111.                         }
  1112.                     ffunlock();
  1113.                     ffreadstatus=0;     /*   ferma la lettura della dir   */
  1114.                     if( (pos=ffshowtop+(gid-11))>ffshown-1 ||
  1115.                             data->line[ pos ].type==0 )
  1116.                         {
  1117.                         DisplayBeep( data->screen );
  1118.                         break;
  1119.                         }
  1120.                     if( pos==lastpos && secs-lsecs<2 &&
  1121.                             (secs-lsecs)*1000000+millisecs-lmillisecs<600000 )
  1122.                         doubleclick=TRUE;
  1123.                     else
  1124.                         doubleclick=FALSE;
  1125.                     lastpos=pos;
  1126.                     lsecs=secs;
  1127.                     lmillisecs=millisecs;
  1128.                     if( data->line[ pos ].type>0 && doubleclick )
  1129.                         {
  1130.                         dlen=strlen( data->path );
  1131.                         if( ffreadstatus==1 ||
  1132.                                 dlen+strlen( data->line[ pos ].name )+1>FFPATHLEN )
  1133.                             {
  1134.                             DisplayBeep( data->screen );
  1135.                             break;
  1136.                             }
  1137.                         if( dlen && data->path[ dlen-1 ]!=':' )
  1138.                             {
  1139.                             data->path[ dlen ]='/';
  1140.                             data->path[ ++dlen ]='\0';
  1141.                             }
  1142.                         strcpy( &(data->path[ dlen ]), data->line[ pos ].name );
  1143.                         ffchangepath();
  1144.                         }
  1145.                     if( data->line[ pos ].type<0 )
  1146.                         {
  1147.                         strcpy( data->file, data->line[ pos ].name );
  1148.                         RefreshGadgets( &ffg21, ffwindow, NULL );
  1149.                         ActivateGadget( &ffg21, ffwindow, NULL);
  1150.                         if( doubleclick )
  1151.                             {
  1152.                             ret=FFOK;
  1153.                             goto fine;
  1154.                             }
  1155.                         }
  1156.                     break;
  1157.                 case 22:
  1158.                 case 23:
  1159.                     if( class==GADGETDOWN )
  1160.                         {
  1161.                         i23=0;
  1162.                         do
  1163.                             {
  1164.                             if( (gid==22 && ffshowtop>0) || (gid==23 && ffshowtop<ffshown-FFLINENUM) )
  1165.                                 {
  1166.                                 gid==22 ? ffshowtop-- : ffshowtop++;
  1167.                                 ffsetprop();
  1168.                                 }
  1169.                             if( !i23 )
  1170.                                 for( ; i23<15000; i23++ )
  1171.                                     if( !(gadget->Flags & SELECTED) )
  1172.                                         break;
  1173.                             }while( gadget->Flags & SELECTED );
  1174.                         }
  1175.                     break;
  1176.                 case 24:
  1177.                     do
  1178.                         {
  1179.                         fflasttop=ffshowtop;
  1180.                         ffshowtop=ffshown>FFLINENUM ? ((ULONG)(ffshown-FFLINENUM)*ffpg24.VertPot+(1<<15))>>16 : 0;
  1181.                         if( ffshowtop!=fflasttop )
  1182.                             ffshowall();
  1183.                         }while( ffg24.Flags & SELECTED );
  1184.                     break;
  1185.                 }
  1186.             }
  1187.         if( hitg )
  1188.             if( !(hitg->Flags & SELECTED) )
  1189.                 {
  1190.                 hitg=NULL;
  1191.                 ffshowall();
  1192.                 }
  1193.         if( ffreadstatus==1 )
  1194.             {
  1195.             ffshown=ffshowtop=0;
  1196.             lastpos=-1;     /*   azzera doppio click   */
  1197.             ffsetprop();
  1198.             data->valid=FALSE;
  1199.             ffunlock();
  1200.             fflock=Lock( data->path, ACCESS_READ );
  1201.             if( fflock )
  1202.                 {
  1203.                 Info( fflock, ffid );
  1204.                 ffoutdiskfree( ((ffid->id_NumBlocks-ffid->id_NumBlocksUsed)*ffid->id_BytesPerBlock)/1024 );
  1205.                 readret=Examine( fflock, fffib );
  1206.                 if( readret && fffib->fib_DirEntryType>0 )
  1207.                     ffreadstatus=2;
  1208.                 else
  1209.                     ffunlock();        /* Adesso esegui |  */
  1210.                 }                      /*               |  */
  1211.             if( !fflock )              /*             <-   */
  1212.                 {
  1213.                 DisplayBeep( data->screen );
  1214.                 ffoutdiskfree( FFDFNOVALID );
  1215.                 data->valid=TRUE;
  1216.                 ffreadstatus=0;
  1217.                 }
  1218.             }
  1219.         if( ffreadstatus==2 )
  1220.             {
  1221.             readret=ExNext( fflock, fffib );
  1222.             if( readret )
  1223.                 ffaddline();
  1224.             else
  1225.                 {
  1226.                 ffunlock();
  1227.                 ffreadstatus=0;
  1228.                 data->valid=TRUE;
  1229.                 }
  1230.             }
  1231.         }
  1232.  
  1233. fine:
  1234.     data->file[ FFFILELEN-strlen(data->suffix) ]='\0';
  1235.     strcpy( data->complete, data->path );
  1236.     dlen=strlen( data->complete );
  1237.     if( dlen && data->path[ dlen-1 ]!=':' )
  1238.         {
  1239.         data->complete[ dlen ]='/';
  1240.         data->complete[ ++dlen ]='\0';
  1241.         }
  1242.     strcpy( &(data->complete[ dlen ]), data->file );
  1243.     strcpy( &(data->complete[ strlen(data->complete) ]), data->suffix );
  1244.     data->shown=ffshown;
  1245.     data->showtop=ffshowtop;
  1246.     data->diskfree=ffdiskfree;
  1247.  
  1248.     ffunlock();
  1249.     if( ffwindow )
  1250.         CloseWindow( ffwindow );
  1251.     if( fffib )
  1252.         FreeMem( fffib, sizeof(struct FileInfoBlock) );
  1253.     if( ffid )
  1254.         FreeMem( ffid, sizeof(struct InfoData) );
  1255.  
  1256.     return( ret );
  1257. }
  1258.  
  1259.  
  1260. /*****   Apre finestra e disegna tutto   *****/
  1261. LONG ffopenwindow( void )
  1262. {
  1263.     struct  TextFont    *font;
  1264.  
  1265.     ffnewwindow.LeftEdge=(ffdatag->screen->Width)/2-FFWWIDTH/2;
  1266.     ffnewwindow.TopEdge=(ffdatag->screen->Height)/2-FFWHEIGHT/2;
  1267.     ffnewwindow.Title=ffdatag->title;
  1268.     ffnewwindow.Screen=ffdatag->screen;
  1269.  
  1270.     ffwindow=(struct Window *)OpenWindow( &ffnewwindow );
  1271.     if( ffwindow==NULL )
  1272.         return( 1 );
  1273.     ffrp=ffwindow->RPort;
  1274.  
  1275.     font=(struct TextFont *)OpenFont( &fffont );
  1276.     SetFont( ffrp, font );
  1277.  
  1278.     SetBPen( ffrp, FFCOLORB );
  1279.     SetAPen( ffrp, FFCOLORA );
  1280.     RectFill( ffrp, 2, FFWTOP+1, FFWWIDTH-1-2, FFWHEIGHT-1-1 );
  1281.     SetAPen( ffrp, FFCOLORB );
  1282.     RectFill( ffrp, 4, FFWTOP+2, FFWWIDTH-1-4, FFWHEIGHT-1-2 );
  1283.     SetAPen( ffrp, FFCOLORS );
  1284.     RectFill( ffrp, 235, 44+FFWTOP, 64+4+235-1, 10+44+FFWTOP-1 );
  1285.     RectFill( ffrp, 51, 56+FFWTOP, 248+4+51-1, 10+56+FFWTOP-1 );
  1286.     RectFill( ffrp, 51, 146+FFWTOP, 248+4+51-1, 10+146+FFWTOP-1 );
  1287.     SetAPen( ffrp, FFCOLORA );
  1288.     RectFill( ffrp, 279, 80+FFWTOP, 302, 131+FFWTOP );
  1289.     DrawBorder( ffrp, &ffb0, 9, 41+FFWTOP );
  1290.  
  1291.     fffinddevices();
  1292.  
  1293.     AddGList( ffwindow, &ffg1, 0, -1, NULL );
  1294.     RefreshGadgets( &ffg1, ffwindow, NULL );
  1295.  
  1296.     Move( ffrp, 11, 5+FFWTOP );
  1297.     Draw( ffrp, 11, 20+FFWTOP );
  1298.     Move( ffrp, 12+6*48, 5+FFWTOP );
  1299.     Draw( ffrp, 12+6*48, 20+FFWTOP );
  1300.  
  1301.     ActivateGadget( &ffg21, ffwindow, NULL);
  1302.  
  1303.     return( 0 );
  1304. }
  1305.  
  1306.  
  1307. /*****   Stampa tutto uno schermo di linee   *****/
  1308. void ffshowall( void )
  1309. {
  1310.     COUNT     i;
  1311.     
  1312.     for( i=0; i<FFLINENUM; i++ )
  1313.         {
  1314.         Move( ffrp, 13, 70+i*9+7+FFWTOP );
  1315.         SetAPen( ffrp, ffdatag->line[ ffshowtop+i ].type<0 ? FFCOLORA : FFCOLORA2 );
  1316.         Text( ffrp, ffshowtop+i<ffshown ? ffshow[ ffshowtop+i ] :
  1317.                     "                                 ", FFLINELEN );
  1318.         }
  1319. }
  1320.  
  1321.  
  1322. /*****   Setta il Vert.Body della scroll bar   *****/
  1323. void ffsetprop( void )
  1324. {
  1325.     USHORT  body, pot;
  1326.  
  1327.     body=ffshown>FFLINENUM ? (ULONG)(FFLINENUM*0xFFFF)/ffshown : 0xFFFF;
  1328.     pot=ffshown>FFLINENUM ? FFMIN( 0xFFFF, ((ffshowtop<<16))/(ffshown-FFLINENUM)) : 0;
  1329.     NewModifyProp( &ffg24, ffwindow, NULL, ffpg24.Flags, 0, pot, 0, body, 1 );
  1330.     ffshowall();
  1331. }
  1332.  
  1333.  
  1334. /*****   E` stato modificato il path   *****/
  1335. void ffchangepath( void )
  1336. {
  1337.     ((struct StringInfo *)ffg20.SpecialInfo)->BufferPos=
  1338.             ((struct StringInfo *)ffg20.SpecialInfo)->DispPos=
  1339.             strlen(ffdatag->path)-30>0 ? strlen(ffdatag->path)-30 : 0 ;
  1340.     RefreshGadgets( &ffg20, ffwindow, NULL );
  1341.     ActivateGadget( &ffg21, ffwindow, NULL);
  1342.     ffreadstatus=1;
  1343. }
  1344.  
  1345.  
  1346. /*****   Se c'e` un lock lo toglie   *****/
  1347. void ffunlock( void )
  1348. {
  1349.     if( fflock )
  1350.         {
  1351.         UnLock( fflock );
  1352.         fflock=0;
  1353.         }
  1354. }
  1355.  
  1356.  
  1357. /*****   Aggiunge una linea alla lista dei files   *****/
  1358. LONG ffaddline( void )
  1359. {
  1360.     LONG   pos, i;
  1361.     SHORT   slen, flen;
  1362.  
  1363.     if( ffshown==FFMAXLINE )
  1364.         {
  1365.         ffdatag->line[ --ffshown ].type=0;
  1366.         ffaddshow( ffshown );
  1367.         ffshowall();
  1368.         ffreadstatus=0;
  1369.         ffunlock();
  1370.         ffdatag->valid=TRUE;
  1371.         return( 0 );
  1372.         }
  1373.  
  1374.     slen=0;
  1375.     if( fffib->fib_DirEntryType<0 && (
  1376.             (flen=strlen(fffib->fib_FileName)) < (slen=strlen(ffdatag->suffix)) ||
  1377.             ffstrcmpu( &(fffib->fib_FileName[ flen-slen ]), ffdatag->suffix ) ) )
  1378.         return( 0 );
  1379.  
  1380.     for( pos=0; pos<ffshown; pos++ )
  1381.         if( fffib->fib_DirEntryType>0==ffdatag->line[ pos ].type>0 )
  1382.             {
  1383.             if( ffstrcmpu( fffib->fib_FileName, ffdatag->line[ pos ].name )<0 )
  1384.                 break;
  1385.             }
  1386.         else
  1387.             if( fffib->fib_DirEntryType>0 )
  1388.                 break;
  1389.  
  1390.     for( i=ffshown; i>pos; i-- )
  1391.         ffdatag->line[ i ]=ffdatag->line[ i-1 ];
  1392.  
  1393.     strcpy( ffdatag->line[ pos ].name, fffib->fib_FileName );
  1394.     ffdatag->line[ pos ].name[ strlen(ffdatag->line[ pos ].name)-slen ]='\0';
  1395.     ffdatag->line[ pos ].size=fffib->fib_Size;
  1396.     ffdatag->line[ pos ].type=fffib->fib_DirEntryType;
  1397.     ffaddshow( pos );
  1398.  
  1399.     ffshowtop=ffshown>FFLINENUM ? ((ULONG)((ffshown-1)-FFLINENUM)*ffpg24.VertPot+(1<<15))>>16 : 0;
  1400.     ffsetprop();
  1401. }
  1402.  
  1403.  
  1404. /*****   Aggiunge una linea a show alla posizione pos   *****/
  1405. LONG ffaddshow( LONG pos )
  1406. {
  1407.     COUNT   i;
  1408.     BYTE    buff[ 9 ];
  1409.     
  1410.     if( ffdatag->line[ ffshown ].type==0 )
  1411.         {
  1412.         strcpy( ffshow[ ffshown++ ], "*******  TOO MANY FILES  ********");
  1413.         return( 0 );
  1414.         }
  1415.     
  1416.     for( i=ffshown; i>pos; i-- )
  1417.         strcpy( ffshow[ i ], ffshow[ i-1 ] );
  1418.  
  1419.     buff[ 0 ]=' ';
  1420.  
  1421.     strcpy( ffshow[ pos ], ffdatag->line[ pos ].name );
  1422.     for( i=strlen(ffshow[ pos ]); i<FFLINELEN; i++ )
  1423.         ffshow[ pos ][ i ]=' ';
  1424.     if( ffdatag->line[ pos ].type<0 )
  1425.         {
  1426.         i=stcu_d( &(buff[ 1 ]), ffdatag->line[ pos ].size );
  1427.         strcpy( &(ffshow[ pos ][ FFLINELEN-i-1 ]), buff );
  1428.         }
  1429.     else
  1430.         strcpy( &(ffshow[ pos ][27]), " <Dir>" );
  1431.     ffshown++;
  1432.  
  1433. }
  1434.  
  1435.  
  1436. /*****   Compara due stringe considerate Uppercase   *****/
  1437. ffstrcmpu( s, t )
  1438.     UBYTE   *s, *t;
  1439. {
  1440.     while( *s && *t && FFTOUP( *s )==FFTOUP( *t ) )
  1441.         {
  1442.         ++s;
  1443.         ++t;
  1444.         }
  1445.     return( (LONG)( FFTOUP( *s )-FFTOUP( *t ) ) );
  1446. }
  1447.  
  1448.  
  1449. /*****   Stampa memoria libera su disco   *****/
  1450. void ffoutdiskfree( ULONG k )
  1451. {
  1452.     BYTE    buff[ 7 ];
  1453.     SHORT   i;
  1454.  
  1455.     SetAPen( ffrp, FFCOLORDF0 );
  1456.     RectFill( ffrp, 11, 42+FFWTOP, 11-1+17*8+4, 42-1+11+FFWTOP );
  1457.     SetAPen( ffrp, FFCOLORDF1 );
  1458.     SetDrMd( ffrp, JAM1 );
  1459.  
  1460.     if( k==FFDFNOVALID )
  1461.         {
  1462.         Move( ffrp, 13, 50+FFWTOP );
  1463.         Text( ffrp, novalidpath, NOVALIDPATHLEN );
  1464.         SetAPen( ffrp, FFCOLORDF2 );
  1465.         Move( ffrp, 13+2, 50+FFWTOP );
  1466.         Text( ffrp, novalidpath, NOVALIDPATHLEN );
  1467.         }
  1468.     else
  1469.         {
  1470.         i=stcu_d( buff, k );
  1471.         Move( ffrp, 13, 50+FFWTOP );
  1472.         Text( ffrp, "Disk free:", 10 );
  1473.         Text( ffrp, buff, i );
  1474.         SetAPen( ffrp, FFCOLORDF2 );
  1475.         Move( ffrp, 13+10*8+2, 50+FFWTOP );
  1476.         Text( ffrp, buff, i );
  1477.         SetAPen( ffrp, FFCOLORDF1 );
  1478.         Text( ffrp, "k", 1 );
  1479.         }
  1480.  
  1481.     SetDrMd( ffrp, JAM2 );
  1482.     ffdiskfree=k;
  1483. }
  1484.  
  1485.  
  1486. /*****   Cerca i DEVICES realmente esistenti   *****/
  1487. void fffinddevices( void )
  1488. {
  1489.     struct  DeviceList  *dev;
  1490.     UBYTE   *name;
  1491.     struct  Gadget  *g;
  1492.     COUNT   i;
  1493.  
  1494.     for( g=&ffg1; g!=&ffg7; g=g->NextGadget )
  1495.         g->Flags|=GADGDISABLED;
  1496.     dev=(struct DeviceList *)BADDR( (((struct DosInfo *)BADDR( ((struct RootNode *)DOSBase->dl_Root)->rn_Info ))->di_DevInfo) );
  1497.     do
  1498.         {
  1499.         if( dev->dl_Type!=DLT_DEVICE )
  1500.             continue;
  1501.         name=(UBYTE *)BADDR( (LONG)(dev->dl_Name) );
  1502.         if( *(name++)!=3 )
  1503.             continue;        /* uso solo devices di 3 lettere */
  1504.         for( g=&ffg1; g!=&ffg7; g=g->NextGadget )
  1505.             {
  1506.             for( i=0; i<3; ++i )
  1507.                 if( *(name+i)!=*(g->GadgetText->IText+i) )
  1508.                     break;
  1509.             if( i==3 )
  1510.                 g->Flags^=GADGDISABLED;
  1511.             }
  1512.         }while( dev=(struct DeviceList *)BADDR( dev->dl_Next ) );
  1513. }
  1514.  
  1515.  
  1516.  
  1517. /******************   Fine routines FILE-FINDER   ***************************/
  1518.  
  1519.